export default {
	//判断参数类型
	getConstType(...arguments) {
		const typeResult = arguments.map((item) => {
			return Object.prototype.toString.call(item).slice(8, -1).toLowerCase()
		})

		if (typeResult.length === 1) {
			return typeResult[0]
		} else {
			return typeResult
		}
	}

	//深拷贝
	deepClone(obj) {
		//obj是null,或者不是对象和数组，直接返回
		//（object 是引用类型的对象、数组、null的typeof值）     
		if (typeof obj !== 'object' || obj == null) {
			return obj
		}
		//初始化返回结果
		let result
		if (obj instanceof Array) {
			result = []
		} else {
			result = {}
		}
		for (let key in obj) {
			//保证key不是原型的属性
			if (obj.hasOwnProperty(key)) {
				//递归调用
				result[key] = deepClone(obj[key])
			}
		}
		// 返回结果
		return result
	}

	//获取url中的参数
	getParams(url = location.href) {
		if (!url || typeof url !== 'string') {
			return '地址解析格式错误'
		}
		let a = url.split('?')[1] || ''
		if (
			a !== '' &&
			(a.split('&').length !== 0 || a.split('&&').length !== 0)
		) {
			let b = a.split('&') || a.split('&&')
			let c = {}
			b.forEach((item) => {
				let key = item.split('=')[0]
				let value = item.split('=')[1]
				c[key] = value
			})
			return c
		} else {
			return 'error'
		}
	}

	debounce(fn, delay = 3000, immediate = true) {
		//要执行防抖的函数，时间延迟,是否立即执行
		let timer = null
		if (immediate) {
			//如果需要立即执行则直接执行
			fn()
		}
		return function() {
			//此段是第一次函数执行之后的一直执行的匿名函数
			if (timer) {
				//如果有定时器说明用户还在等待延时的区间中 则清除这个定时器 重新创建新的定时器 让用户重新等待延时的时间
				clearTimeout(timer)
			}
			//如果用户等待延时完成 settimeout会触发待执行的函数
			timer = setTimeout(fn, delay)
		}
	}

	throttle(fn, delay = 1000) {
		//在规定时间内多次请求只会触发一次，不响应后续请求
		let vaild = true //定义函数是否在工作中
		return function() {
			if (!vaild) {
				//如果在工作中则不理会、不触发
				return false
			}
			// vaild = false
			setTimeout(() => {
				//没在工作状态执行指定函数，并将状态改为正在执行中，不接受后续触发请求
				fn()
				vaild = true
			}, delay)
		}
	}
}